diff -r 3501986de11d -r 464191b6f4d7 Lib/ntpath.py
--- a/Lib/ntpath.py	Sun May 31 21:44:27 2009 +0200
+++ b/Lib/ntpath.py	Fri Jun 05 12:37:33 2009 -0400
@@ -306,13 +306,19 @@
     return split(p)[0]
 
 # Is a path a symbolic link?
-# This will always return false on systems where posix.lstat doesn't exist.
+# This will always return false on systems where os.lstat doesn't exist.
 
 def islink(path):
-    """Test for symbolic link.
-    On WindowsNT/95 and OS/2 always returns false
     """
-    return False
+    Test whether a path is a symbolic link.
+    This will always return false for Windows prior to 6.0
+    and for OS/2.
+    """
+    try:
+        st = os.lstat(path)
+    except (os.error, AttributeError):
+        return False
+    return stat.S_ISLNK(st.st_mode)
 
 # alias exists to lexists
 lexists = exists
diff -r 3501986de11d -r 464191b6f4d7 Lib/test/test_win_symlink.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Lib/test/test_win_symlink.py	Fri Jun 05 12:37:33 2009 -0400
@@ -0,0 +1,54 @@
+import os
+import sys
+import stat
+
+import unittest
+
+class WindowsSymlinkTest(unittest.TestCase):
+	filelink = r'filelinktest'
+	filelink_target = os.path.abspath(__file__)
+	dirlink = r'dirlinktest'
+	dirlink_target = os.path.dirname(filelink_target)
+	
+	def setUp(self):
+		if (not hasattr(sys, 'getwindowsversion') or
+			sys.getwindowsversion() < (6,)
+			): raise Exception("This test requires Windows Vista or greater")
+
+		assert os.path.exists(self.dirlink_target)
+		assert os.path.exists(self.filelink_target)
+		assert not os.path.exists(self.dirlink)
+		assert not os.path.exists(self.filelink)
+
+	def test_directory_link(self):
+		os.symlink(self.dirlink, self.dirlink_target)
+		self.assertTrue(os.path.exists(self.dirlink))
+		self.assertTrue(os.path.isdir(self.dirlink))
+		self.assertTrue(os.path.islink(self.dirlink))
+		self.check_stat(self.dirlink, self.dirlink_target)
+
+	def test_file_link(self):
+		os.symlink(self.filelink, self.filelink_target)
+		self.assertTrue(os.path.exists(self.filelink))
+		self.assertTrue(os.path.isfile(self.filelink))
+		self.assertTrue(os.path.islink(self.filelink))
+		self.check_stat(self.filelink, self.filelink_target)
+
+	def test_remove_directory_link_to_missing_target(self):
+		linkname = "missing link"
+		os.symlink(linkname, r'c:\\target does not exist.29r3c740', True)
+		# self.assertTrue(os.path.isdir(linkname)) # fails
+		# even though it's not a dir, it has to be removed as a dir
+		self.assertRaises(WindowsError, os.remove, linkname)
+		os.rmdir(linkname)
+
+	def check_stat(self, link, target):
+		self.assertEqual(os.stat(link), os.stat(target))
+		self.assertNotEqual(os.lstat(link), os.stat(link))
+
+	def tearDown(self):
+		if os.path.exists(self.filelink): os.remove(self.filelink)
+		if os.path.exists(self.dirlink): os.rmdir(self.dirlink)
+
+if __name__ == "__main__":
+	unittest.main()
diff -r 3501986de11d -r 464191b6f4d7 Modules/posixmodule.c
--- a/Modules/posixmodule.c	Sun May 31 21:44:27 2009 +0200
+++ b/Modules/posixmodule.c	Fri Jun 05 12:37:33 2009 -0400
@@ -618,7 +618,7 @@
 
 #ifdef MS_WINDOWS
 static PyObject *
-win32_error(char* function, char* filename)
+win32_error(char* function, const char* filename)
 {
 	/* XXX We should pass the function name along in the future.
 	   (winreg.c also wants to pass the function name.)
@@ -1115,12 +1115,31 @@
 	return attributes_from_dir_w(pszFile, pfad);
 }
 
+/*
+About the following functions: win32_lstat, win32_lstat_w,
+	win32_stat, win32_stat_w
+	
+	In Posix, stat automatically traverses symlinks and returns
+	the stat structure for the target.  In Windows, the equivalent
+	GetFileAttributes by default does not traverse symlinks and
+	instead returns attributes for the symlink.
+	
+	Therefore, win32_lstat will get the attributes traditionally,
+	and win32_stat will first explicitly resolve the symlink target
+	and then will call win32_lstat on that result.
+	
+	The _w represent Unicode equivalents of the aformentioned ANSI
+	functions.
+*/
+
 static int 
-win32_stat(const char* path, struct win32_stat *result)
+win32_lstat(const char* path, struct win32_stat *result)
 {
 	WIN32_FILE_ATTRIBUTE_DATA info;
 	int code;
 	char *dot;
+	WIN32_FIND_DATAA find_data;
+	HANDLE find_data_handle;
 	/* XXX not supported on Win95 and NT 3.x */
 	if (!Py_GetFileAttributesExA(path, GetFileExInfoStandard, &info)) {
 		if (GetLastError() != ERROR_SHARING_VIOLATION) {
@@ -1141,6 +1160,25 @@
 	code = attribute_data_to_stat(&info, result);
 	if (code != 0)
 		return code;
+
+	/* Get WIN32_FIND_DATA structure for the path to determine if
+	   it is a symlink */
+	if(info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
+	{
+		find_data_handle = FindFirstFileA(path, &find_data);
+		if(find_data_handle != INVALID_HANDLE_VALUE)
+		{
+			if(find_data.dwReserved0 == IO_REPARSE_TAG_SYMLINK)
+			{
+				/* first clear the S_IFMT bits */
+				result->st_mode ^= (result->st_mode & 0170000);
+				/* now set the bits that make this a symlink */
+				result->st_mode |= 0120000;
+			}
+			FindClose(find_data_handle);
+		}
+	}
+
 	/* Set S_IFEXEC if it is an .exe, .bat, ... */
 	dot = strrchr(path, '.');
 	if (dot) {
@@ -1154,11 +1192,13 @@
 }
 
 static int 
-win32_wstat(const wchar_t* path, struct win32_stat *result)
+win32_lstat_w(const wchar_t* path, struct win32_stat *result)
 {
 	int code;
 	const wchar_t *dot;
 	WIN32_FILE_ATTRIBUTE_DATA info;
+	WIN32_FIND_DATAW find_data;
+	HANDLE find_data_handle;
 	/* XXX not supported on Win95 and NT 3.x */
 	if (!Py_GetFileAttributesExW(path, GetFileExInfoStandard, &info)) {
 		if (GetLastError() != ERROR_SHARING_VIOLATION) {
@@ -1179,6 +1219,25 @@
 	code = attribute_data_to_stat(&info, result);
 	if (code < 0)
 		return code;
+
+	/* Get WIN32_FIND_DATA structure for the path to determine if
+	   it is a symlink */
+	if(info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
+	{
+		find_data_handle = FindFirstFileW(path, &find_data);
+		if(find_data_handle != INVALID_HANDLE_VALUE)
+		{
+			if(find_data.dwReserved0 == IO_REPARSE_TAG_SYMLINK)
+			{
+				/* first clear the S_IFMT bits */
+				result->st_mode ^= (result->st_mode & 0170000);
+				/* now set the bits that make this a symlink */
+				result->st_mode |= 0120000;
+			}
+			FindClose(find_data_handle);
+		}
+	}
+
 	/* Set IFEXEC if it is an .exe, .bat, ... */
 	dot = wcsrchr(path, '.');
 	if (dot) {
@@ -1191,6 +1250,117 @@
 	return code;
 }
 
+/* Grab GetFinalPathNamyByHandle dynamically from kernel32 */
+static int has_GetFinalPathNameByHandle = 0;
+static DWORD (CALLBACK *Py_GetFinalPathNameByHandleA)(HANDLE, LPSTR, DWORD, DWORD);
+static DWORD (CALLBACK *Py_GetFinalPathNameByHandleW)(HANDLE, LPWSTR, DWORD, DWORD);
+static int
+check_GetFinalPathNameByHandle()
+{
+	HINSTANCE hKernel32;
+	/* only recheck */
+	if (!has_GetFinalPathNameByHandle)
+	{
+		hKernel32 = GetModuleHandle("KERNEL32");
+		*(FARPROC*)&Py_GetFinalPathNameByHandleA = GetProcAddress(hKernel32, "GetFinalPathNameByHandleA");
+		*(FARPROC*)&Py_GetFinalPathNameByHandleW = GetProcAddress(hKernel32, "GetFinalPathNameByHandleW");
+		has_GetFinalPathNameByHandle = Py_GetFinalPathNameByHandleA && Py_GetFinalPathNameByHandleW;
+	}
+	return has_GetFinalPathNameByHandle;
+}
+
+static int
+win32_stat(const char* path, struct win32_stat *result)
+{
+	/* Traverse the symlink to the target using
+	GetFinalPathNameByHandle()
+	*/
+	int code;
+	HANDLE hFile;
+	int buf_size;
+	char *target_path;
+	int result_length;
+	
+	if(!check_GetFinalPathNameByHandle())
+	{
+		return win32_lstat(path, result);
+	}
+
+	hFile = CreateFileA(
+		path,
+		0, /* desired access */
+		0, /* share mode */
+		NULL, /* security attributes */
+		OPEN_EXISTING,
+		/* FILE_FLAG_BACKUP_SEMANTICS is required to open a directory */
+		FILE_ATTRIBUTE_NORMAL|FILE_FLAG_BACKUP_SEMANTICS,
+		NULL);
+	
+	if(hFile == INVALID_HANDLE_VALUE)
+	{
+		return -1;
+	}
+	
+	buf_size = Py_GetFinalPathNameByHandleA(hFile, 0, 0, VOLUME_NAME_DOS);
+	if(!buf_size) return -1;
+	target_path = (char *)malloc((buf_size+1)*sizeof(char));
+	result_length = Py_GetFinalPathNameByHandleA(hFile, target_path, buf_size, VOLUME_NAME_DOS);
+	
+	if(!result_length) return -1;
+	if(!CloseHandle(hFile)) return -1;
+	target_path[result_length] = 0;
+	code = win32_lstat(target_path, result);
+	free(target_path);
+	
+	return code;
+}
+
+static int 
+win32_stat_w(const wchar_t* path, struct win32_stat *result)
+{
+	/* Traverse the symlink to the target using
+	GetFinalPathNameByHandle()
+	*/
+	int code;
+	HANDLE hFile;
+	int buf_size;
+	wchar_t *target_path;
+	int result_length;
+	
+	if(!check_GetFinalPathNameByHandle())
+	{
+		return win32_lstat_w(path, result);
+	}
+
+	hFile = CreateFileW(
+		path,
+		0, /* desired access */
+		0, /* share mode */
+		NULL, /* security attributes */
+		OPEN_EXISTING,
+		/* FILE_FLAG_BACKUP_SEMANTICS is required to open a directory */
+		FILE_ATTRIBUTE_NORMAL|FILE_FLAG_BACKUP_SEMANTICS,
+		NULL);
+	
+	if(hFile == INVALID_HANDLE_VALUE)
+	{
+		return -1;
+	}
+	
+	buf_size = Py_GetFinalPathNameByHandleW(hFile, 0, 0, VOLUME_NAME_DOS);
+	if(!buf_size) return -1;
+	target_path = (wchar_t *)malloc((buf_size+1)*sizeof(wchar_t));
+	result_length = Py_GetFinalPathNameByHandleW(hFile, target_path, buf_size, VOLUME_NAME_DOS);
+	
+	if(!result_length) return -1;
+	if(!CloseHandle(hFile)) return -1;
+	target_path[result_length] = 0;
+	code = win32_lstat_w(target_path, result);
+	free(target_path);
+	
+	return code;
+}
+
 static int
 win32_fstat(int file_number, struct win32_stat *result)
 {
@@ -2793,7 +2963,7 @@
 posix_stat(PyObject *self, PyObject *args)
 {
 #ifdef MS_WINDOWS
-	return posix_do_stat(self, args, "O&:stat", STAT, "U:stat", win32_wstat);
+	return posix_do_stat(self, args, "O&:stat", STAT, "U:stat", win32_stat_w);
 #else
 	return posix_do_stat(self, args, "O&:stat", STAT, NULL, NULL);
 #endif
@@ -4658,7 +4828,7 @@
 	return posix_do_stat(self, args, "O&:lstat", lstat, NULL, NULL);
 #else /* !HAVE_LSTAT */
 #ifdef MS_WINDOWS
-	return posix_do_stat(self, args, "O&:lstat", STAT, "U:lstat", win32_wstat);
+	return posix_do_stat(self, args, "O&:lstat", win32_lstat, "U:lstat", win32_lstat_w);
 #else
 	return posix_do_stat(self, args, "O&:lstat", STAT, NULL, NULL);
 #endif
@@ -4735,6 +4905,84 @@
 }
 #endif /* HAVE_SYMLINK */
 
+#if !defined(HAVE_SYMLINK) && defined(MS_WINDOWS)
+
+/* Grab CreateSymbolicLinkW dynamically from kernel32 */
+static int has_CreateSymbolicLinkW = 0;
+static DWORD (CALLBACK *Py_CreateSymbolicLinkW)(LPWSTR, LPWSTR, DWORD);
+static int
+check_CreateSymbolicLinkW()
+{
+	HINSTANCE hKernel32;
+	/* only recheck */
+	if (has_CreateSymbolicLinkW)
+	    return has_CreateSymbolicLinkW;
+	hKernel32 = GetModuleHandle("KERNEL32");
+	*(FARPROC*)&Py_CreateSymbolicLinkW = GetProcAddress(hKernel32, "CreateSymbolicLinkW");
+	if (Py_CreateSymbolicLinkW)
+		has_CreateSymbolicLinkW = 1;
+	return has_CreateSymbolicLinkW;
+}
+
+PyDoc_STRVAR(win_symlink__doc__,
+"symlink(src, dest, target_is_directory=False)\n\n\
+Create a symbolic link pointo to src named dst.\n\n\
+target_is_directory is required if the target is to be interpreted as\n\n\
+a directory.\\\
+This function requires Windows 6.0 or greater, and raises a\n\n\
+NotImplementedError otherwise.");
+
+static PyObject *
+win_symlink(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+	static char *kwlist[] = {"src", "dest", "target_is_directory", NULL};
+	PyObject *src, *dest;
+	int target_is_directory = 0;
+	DWORD res;
+	WIN32_FILE_ATTRIBUTE_DATA dest_info;
+	
+	if (!check_CreateSymbolicLinkW())
+	{
+		/* raise NotImplementedError */
+		return PyErr_Format(PyExc_NotImplementedError,
+			"CreateSymbolicLinkW not found");
+	}
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|i:symlink",
+		kwlist, &src, &dest, &target_is_directory))
+		return NULL;
+	if (!convert_to_unicode(&src)) { return NULL; }
+	if (!convert_to_unicode(&dest)) {
+		Py_DECREF(src);
+		return NULL;
+	}
+	
+	/* if dest is a directory, ensure target_is_directory==1 */
+	if(
+		Py_GetFileAttributesExW(
+			PyUnicode_AsUnicode(dest), GetFileExInfoStandard, &dest_info
+		))
+	{
+		target_is_directory = target_is_directory ||
+			(dest_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
+	}
+
+	Py_BEGIN_ALLOW_THREADS
+	res = Py_CreateSymbolicLinkW(
+		PyUnicode_AsUnicode(src),
+		PyUnicode_AsUnicode(dest),
+		target_is_directory);
+	Py_END_ALLOW_THREADS
+	Py_DECREF(src);
+	Py_DECREF(dest);
+	if (!res)
+	{
+		return win32_error_unicode("symlink", PyUnicode_AsUnicode(src));
+	}
+	
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+#endif /* !defined(HAVE_SYMLINK) && defined(MS_WINDOWS) */
 
 #ifdef HAVE_TIMES
 #if defined(PYCC_VACPP) && defined(PYOS_OS2)
@@ -7099,6 +7347,9 @@
 #ifdef HAVE_SYMLINK
 	{"symlink",	posix_symlink, METH_VARARGS, posix_symlink__doc__},
 #endif /* HAVE_SYMLINK */
+#if !defined(HAVE_SYMLINK) && defined(MS_WINDOWS)
+	{"symlink", (PyCFunction)win_symlink, METH_VARARGS | METH_KEYWORDS, win_symlink__doc__},
+#endif /* !defined(HAVE_SYMLINK) && defined(MS_WINDOWS)
 #ifdef HAVE_SYSTEM
 	{"system",	posix_system, METH_VARARGS, posix_system__doc__},
 #endif